package com.obggtc.picture.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

/**
 * 图片缓存工具类
 */
@Component
public class ImageCacheUtils {

    @Autowired
    private RedisUtils redisUtils;

    // Redis Key前缀
    private static final String IMAGE_INFO_PREFIX = "image:info:";
    private static final String IMAGE_VIEW_COUNT_PREFIX = "image:view:";
    private static final String HOT_IMAGES_KEY = "image:hot:list";
    private static final String USER_IMAGES_PREFIX = "user:images:";
    private static final String IMAGE_TAGS_PREFIX = "image:tags:";
    private static final String TAG_IMAGES_PREFIX = "tag:images:";
    private static final String RECENT_UPLOADS_KEY = "image:recent:uploads";

    // 默认缓存时间（秒）
    private static final long DEFAULT_CACHE_TIME = 3600; // 1小时
    private static final long HOT_IMAGES_CACHE_TIME = 1800; // 30分钟
    private static final long VIEW_COUNT_CACHE_TIME = 86400; // 24小时

    /**
     * 缓存图片基本信息
     * @param imageId 图片ID
     * @param imageInfo 图片信息（包含文件名、大小、类型等）
     */
    public void cacheImageInfo(String imageId, Map<String, Object> imageInfo) {
        String key = IMAGE_INFO_PREFIX + imageId;
        redisUtils.hmset(key, imageInfo, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取图片基本信息
     * @param imageId 图片ID
     * @return 图片信息
     */
    public Map<Object, Object> getImageInfo(String imageId) {
        String key = IMAGE_INFO_PREFIX + imageId;
        return redisUtils.hmget(key);
    }

    /**
     * 删除图片缓存信息
     * @param imageId 图片ID
     */
    public void removeImageInfo(String imageId) {
        String key = IMAGE_INFO_PREFIX + imageId;
        redisUtils.del(key);
    }

    /**
     * 增加图片访问次数
     * @param imageId 图片ID
     * @return 当前访问次数
     */
    public long incrementViewCount(String imageId) {
        String key = IMAGE_VIEW_COUNT_PREFIX + imageId;
        long count = redisUtils.incr(key, 1);
        // 设置过期时间
        if (count == 1) {
            redisUtils.expire(key, VIEW_COUNT_CACHE_TIME);
        }
        return count;
    }

    /**
     * 获取图片访问次数
     * @param imageId 图片ID
     * @return 访问次数
     */
    public long getViewCount(String imageId) {
        String key = IMAGE_VIEW_COUNT_PREFIX + imageId;
        Object count = redisUtils.get(key);
        return count != null ? Long.parseLong(count.toString()) : 0L;
    }

    /**
     * 批量获取图片访问次数
     * @param imageIds 图片ID列表
     * @return 访问次数映射
     */
    public Map<String, Long> batchGetViewCounts(List<String> imageIds) {
        Map<String, Long> result = new java.util.HashMap<>();
        for (String imageId : imageIds) {
            result.put(imageId, getViewCount(imageId));
        }
        return result;
    }

    /**
     * 添加到热门图片列表
     * @param imageId 图片ID
     * @param score 热度分数（可以基于访问量、点赞数等计算）
     */
    public void addToHotImages(String imageId, double score) {
        // 使用列表存储，先添加再排序或者使用简单的列表存储
        redisUtils.lSet(HOT_IMAGES_KEY, imageId);
        // 保持列表大小
        long size = redisUtils.lGetListSize(HOT_IMAGES_KEY);
        if (size > 100) {
            redisUtils.lRemove(HOT_IMAGES_KEY, -1, 
                redisUtils.lGetIndex(HOT_IMAGES_KEY, -1));
        }
        redisUtils.expire(HOT_IMAGES_KEY, HOT_IMAGES_CACHE_TIME);
    }

    /**
     * 获取热门图片列表
     * @param count 返回数量
     * @return 热门图片ID列表
     */
    public List<Object> getHotImages(int count) {
        return redisUtils.lGet(HOT_IMAGES_KEY, 0, count - 1);
    }

    /**
     * 缓存用户的图片列表
     * @param username 用户名
     * @param imageIds 图片ID列表
     */
    public void cacheUserImages(String username, List<String> imageIds) {
        String key = USER_IMAGES_PREFIX + username;
        redisUtils.del(key); // 先清除旧数据
        if (!imageIds.isEmpty()) {
            redisUtils.lSet(key, imageIds, DEFAULT_CACHE_TIME);
        }
    }

    /**
     * 添加用户上传的图片
     * @param username 用户名
     * @param imageId 图片ID
     */
    public void addUserImage(String username, String imageId) {
        String key = USER_IMAGES_PREFIX + username;
        redisUtils.lSet(key, imageId);
        redisUtils.expire(key, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取用户的图片列表
     * @param username 用户名
     * @return 图片ID列表
     */
    public List<Object> getUserImages(String username) {
        String key = USER_IMAGES_PREFIX + username;
        return redisUtils.lGet(key, 0, -1);
    }

    /**
     * 从用户图片列表中移除图片
     * @param username 用户名
     * @param imageId 图片ID
     */
    public void removeUserImage(String username, String imageId) {
        String key = USER_IMAGES_PREFIX + username;
        redisUtils.lRemove(key, 1, imageId);
    }

    /**
     * 缓存图片标签
     * @param imageId 图片ID
     * @param tags 标签列表
     */
    public void cacheImageTags(String imageId, List<String> tags) {
        String key = IMAGE_TAGS_PREFIX + imageId;
        redisUtils.del(key);
        if (!tags.isEmpty()) {
            redisUtils.lSet(key, tags, DEFAULT_CACHE_TIME);
        }
    }

    /**
     * 获取图片标签
     * @param imageId 图片ID
     * @return 标签列表
     */
    public List<Object> getImageTags(String imageId) {
        String key = IMAGE_TAGS_PREFIX + imageId;
        return redisUtils.lGet(key, 0, -1);
    }

    /**
     * 为标签添加图片
     * @param tag 标签
     * @param imageId 图片ID
     */
    public void addImageToTag(String tag, String imageId) {
        String key = TAG_IMAGES_PREFIX + tag;
        redisUtils.lSet(key, imageId);
        redisUtils.expire(key, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取标签下的图片列表
     * @param tag 标签
     * @return 图片ID列表
     */
    public List<Object> getImagesByTag(String tag) {
        String key = TAG_IMAGES_PREFIX + tag;
        return redisUtils.lGet(key, 0, -1);
    }

    /**
     * 添加到最近上传列表
     * @param imageId 图片ID
     */
    public void addToRecentUploads(String imageId) {
        // 添加到列表头部
        redisUtils.lSet(RECENT_UPLOADS_KEY, imageId);
        
        // 保持列表大小不超过100
        long size = redisUtils.lGetListSize(RECENT_UPLOADS_KEY);
        if (size > 100) {
            // 移除最后的元素
            redisUtils.lRemove(RECENT_UPLOADS_KEY, -1, 
                redisUtils.lGetIndex(RECENT_UPLOADS_KEY, -1));
        }
        
        // 设置过期时间
        redisUtils.expire(RECENT_UPLOADS_KEY, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取最近上传的图片列表
     * @param count 返回数量
     * @return 最近上传的图片ID列表
     */
    public List<Object> getRecentUploads(int count) {
        return redisUtils.lGet(RECENT_UPLOADS_KEY, 0, count - 1);
    }

    /**
     * 缓存图片缩略图信息
     * @param imageId 图片ID
     * @param thumbnailPath 缩略图路径
     * @param thumbnailSize 缩略图大小
     */
    public void cacheThumbnailInfo(String imageId, String thumbnailPath, String thumbnailSize) {
        String key = IMAGE_INFO_PREFIX + imageId;
        redisUtils.hset(key, "thumbnailPath", thumbnailPath, DEFAULT_CACHE_TIME);
        redisUtils.hset(key, "thumbnailSize", thumbnailSize, DEFAULT_CACHE_TIME);
    }

    /**
     * 获取图片缩略图路径
     * @param imageId 图片ID
     * @return 缩略图路径
     */
    public String getThumbnailPath(String imageId) {
        String key = IMAGE_INFO_PREFIX + imageId;
        Object path = redisUtils.hget(key, "thumbnailPath");
        return path != null ? path.toString() : null;
    }

    /**
     * 统计用户上传的图片数量
     * @param username 用户名
     * @return 图片数量
     */
    public long getUserImageCount(String username) {
        String key = USER_IMAGES_PREFIX + username;
        return redisUtils.lGetListSize(key);
    }

    /**
     * 清除所有图片相关缓存
     * @param imageId 图片ID
     */
    public void clearAllImageCache(String imageId) {
        // 清除图片基本信息
        removeImageInfo(imageId);
        
        // 清除访问次数
        String viewCountKey = IMAGE_VIEW_COUNT_PREFIX + imageId;
        redisUtils.del(viewCountKey);
        
        // 清除标签信息
        String tagsKey = IMAGE_TAGS_PREFIX + imageId;
        redisUtils.del(tagsKey);
        
        // 从最近上传列表中移除
        redisUtils.lRemove(RECENT_UPLOADS_KEY, 1, imageId);
    }

    /**
     * 刷新热门图片列表（定时任务使用）
     * 根据访问量等数据重新计算热门图片
     */
    public void refreshHotImagesList() {
        // 这里可以实现根据访问量、点赞数等重新计算热门图片的逻辑
        // 具体实现取决于业务需求
    }
} 